home *** CD-ROM | disk | FTP | other *** search
/ Turnbull China Bikeride / Turnbull China Bikeride - Disc 2.iso / STUTTGART / UTIL / MEMORY / OLD / MEM208SRC / !Memphis / c / inode < prev    next >
Text File  |  1993-09-08  |  6KB  |  228 lines
  1. /*
  2.  * inode.c
  3.  * Part of the !Memphis distribution
  4.  * (c) bdb/nas, 1991-3
  5.  */
  6.  
  7. /************** Inode Module ***************/
  8. /* #define DEBUG */
  9. /*  debug support*/
  10. #ifdef DEBUG
  11. #define DEBUGf printf
  12. #else
  13. #define DEBUGf 1?(void)0:(void)printf
  14. #endif
  15.  
  16. /*  includes*/
  17. #include <stdio.h>
  18. #include "interface.h"
  19. #include "core.h"
  20. #include "store.h"
  21. #include "inode.h"
  22. #include "util.h"
  23.  
  24. /*  errs*/
  25. static DEFERR( mb_root_failed,         0,  "Failed to create root" );
  26. static DEFERR( mb_root_lost,           0,  "Lost root" );
  27.  
  28. /*  prototypes*/
  29. static _kernel_oserror *Inode_CreateRoot(storeid s);
  30.  
  31. /*  vars*/
  32. #define NUMINODES 100
  33.  
  34. static INODE inodetable[NUMINODES];
  35. static int nextinode;
  36. volatile int Inode_flushcount;
  37.  
  38. /* set to zero on something needing flush
  39.  * incremented each second
  40.  * We flush inodes when it reaches FLUSHTIME
  41.  */
  42. #define FLUSHTIME 3
  43.  
  44.  INODE *Inode_Find(storeid s,int inode) /*Find an inode in memory*/
  45. { int i;
  46.   DEBUGf("Inode_Find(%p,%d)\n",s,inode);
  47.   Inode_flushcount=0;
  48. start:
  49.   for (i=0;i<NUMINODES;i++)
  50.     if (inodetable[i].store==s && inodetable[i].inode==inode)
  51.     { inodetable[i].uses++;
  52.       return &inodetable[i];
  53.     }
  54.   for (;inodetable[nextinode].uses;++nextinode>=NUMINODES && (nextinode=0)==0)
  55.     ;
  56.   i=nextinode;
  57.   ++nextinode>=NUMINODES && (nextinode=0)==0;
  58.   if (inodetable[i].changed)
  59.     Store_Write(inodetable[i].store,0,inodetable[i].inode*sizeof(STOREINODE),
  60.                                 sizeof(STOREINODE), &inodetable[i]);
  61.   if (Store_Read( s, 0, inode*sizeof(STOREINODE), sizeof(STOREINODE), &inodetable[i]))
  62.   { inodetable[i].inode = -2;
  63.     inodetable[i].uses = 0;
  64.     inodetable[i].changed = 0;
  65.     if (Inode_CreateRoot(s))
  66.       return NULL;
  67.     goto start;
  68.   }
  69.   inodetable[i].store=s;
  70.   inodetable[i].inode = inode;
  71.   inodetable[i].uses = 1; /* NOW CHANGED TO LOCK IT */
  72.   inodetable[i].changed = 0;
  73.   return &inodetable[i];
  74. }
  75.  
  76.  _kernel_oserror *Inode_EnsureSize( INODE *h, int size )/**/
  77. { _kernel_oserror *err;
  78.   DEBUGf("Inode_EnsureSize(%p,%d)\n",h,size);
  79.   if ( size!=h->allocated)
  80.   { err = Store_SetLength( h->store, h->inode, size );
  81.     if (err)
  82.       return err;
  83.     h->allocated=size;
  84.     Inode_Changed( h );
  85.   }
  86.   return NULL;
  87. }
  88.  
  89. INODE *Inode_New( INODE *p )/**/
  90. { INODE *p0,*d;
  91.   int inode;
  92.   DEBUGf("Inode_New(%p)\n",p);
  93.   Inode_flushcount=0;
  94.   p0 = Inode_Find(p->store,0);
  95.   if (!p0)
  96.     return 0;
  97.   if ( p0->parentinode)
  98.   { inode = p0->parentinode;
  99.     d = Inode_Find(p->store,inode);
  100.     if (!d)
  101.     { Inode_Lose(p0); return 0; }
  102.     p0->parentinode = d->parentinode;
  103.   }
  104.   else
  105.   { inode = p0->allocated/sizeof(STOREINODE);
  106.     p0->allocated+=sizeof(STOREINODE);
  107.     if (Store_SetLength(p0->store,0,p0->allocated))
  108.     { Inode_Lose(p0); return 0; }
  109.     d = Inode_Find(p->store,inode);
  110.   }
  111.   Inode_Changed(p0);
  112.   Inode_Lose(p0);
  113.   if (!d)
  114.     return 0;
  115.   d->d.info.date_type.part_1=0xDEADDEAD;
  116.   d->d.info.date_type.part_2=0xDEADDEAD;
  117.   d->d.length = 0;
  118.   d->allocated = 0;
  119.   d->d.attr = Attr_R | Attr_W;
  120.   d->d.type = 1;
  121.   d->d.buffered = 1;
  122.   d->d.interactive = 0;
  123.   d->d.noosgbpb = 0;
  124.   d->parentinode = p->inode;
  125.   Inode_Changed(d);
  126. #ifdef DEBUG
  127.   printf( "Created inode %d\n", d->inode );
  128. #endif
  129.   return d;
  130. }
  131.  
  132.  _kernel_oserror *Inode_Delete( INODE *h )/**/
  133. {
  134.   INODE *t0;
  135.   _kernel_oserror *err;
  136.   DEBUGf("Inode_Delete(%p)\n",h);
  137.   Inode_flushcount=0;
  138.   t0 = Inode_Find(h->store,0);
  139.   if (!t0)
  140.     return ERR(mb_root_lost);
  141.   h->parentinode = t0->parentinode;
  142.   err=Store_SetLength( h->store, h->inode, 0 );
  143.   t0->parentinode = h->inode;
  144.   Inode_Changed(t0);
  145.   Inode_Lose(t0);
  146.   Inode_Changed(h);
  147.   Inode_Lose(h);
  148.   return err;
  149. }
  150.  
  151.  static _kernel_oserror *Inode_CreateRoot(storeid s) /**/
  152. {
  153.     INODE *p0,*inode;
  154.     _kernel_oserror *err;
  155.     DEBUGf("Inode_CreateRoot(%p)\n",s);
  156.     Inode_flushcount=0;
  157.     err = Store_SetLength( s,0,sizeof(STOREINODE));
  158.     if ( err )
  159.       return err;
  160.     p0 = Inode_Find( s,0 );
  161.     if ( !p0 )
  162.       return ERR( mb_root_failed );
  163.     StampInfo( &p0->d.info );
  164.     p0->d.attr=0x12345678;
  165.     p0->d.length=1;
  166.     p0->allocated=sizeof(STOREINODE);
  167.     p0->parentinode=0;   /* chain of free inodes */
  168.     Inode_Changed( p0 );
  169.     inode = Inode_New(p0);
  170.     Inode_Lose(p0);
  171.     if (!inode)
  172.       return ERR( mb_root_failed );
  173.     inode->d.type = 2;
  174.     inode->parentinode = 1;
  175.     StampInfo( &inode->d.info );
  176.     Inode_Changed(inode);
  177.     Inode_Lose(inode);
  178.     return NULL;
  179. }
  180.  
  181. /*  Inode_Read,Write,Init,Finish,Flush,Ticker*/
  182. _kernel_oserror *Inode_Init(void)
  183. { int i;
  184.   for (i=0;i<NUMINODES;i++)
  185.   { inodetable[i].inode=-2;
  186.     inodetable[i].uses=0;
  187.     inodetable[i].changed=0;
  188.   }
  189.   Inode_flushcount = FLUSHTIME+1;     /* no need to flush */
  190.   return Store_Init();
  191. }
  192.  
  193. void Inode_Flush(void)
  194. { int i;
  195.   DEBUGf("***Flush***");
  196.   for (i=0;i<NUMINODES;i++)
  197.   { if (inodetable[i].changed)
  198.     { Store_Write(inodetable[i].store,0,inodetable[i].inode*sizeof(STOREINODE),
  199.                                 sizeof(STOREINODE), &inodetable[i]);
  200.       inodetable[i].changed=0;
  201.     }
  202.     if (!inodetable[i].uses)
  203.       inodetable[i].inode=-2;
  204.   }
  205.   Store_Flush();
  206. }
  207. void Inode_Ticker(void)
  208. { /* DEBUGf("Tick!"); */
  209.   if (++Inode_flushcount==FLUSHTIME)
  210.     Inode_Flush();
  211. }
  212.  
  213. _kernel_oserror *Inode_Finish(void)
  214. { Inode_Flush();
  215.   return Store_Finish();
  216. }
  217.  
  218. _kernel_oserror *Inode_Read( INODE *p, int offset, int length, void *ptr )
  219. { return Store_Read( p->store, p->inode, offset, length, ptr );
  220.   Inode_flushcount=0;
  221. }
  222.  
  223. _kernel_oserror *Inode_Write( INODE *p, int offset, int length, void *ptr )
  224. { return Store_Write( p->store, p->inode, offset, length, ptr );
  225.   Inode_flushcount=0;
  226. }
  227.  
  228.